package com.plugin.mybtaisxplus.util;

import com.plugin.mybtaisxplus.dialog.GeneratorSettings;

/**
 * 代码生成过程中的通用工具方法。
 * 包含命名转换、类型映射等。
 */
public final class GeneratorUtils {

    /**
     * 私有构造函数，防止该工具类被实例化。
     */
    private GeneratorUtils() {}

    /**
     * 将下划线命名的字符串转换为驼峰命名。
     * @param str 待转换的字符串 (e.g., "user_name")
     * @param firstCharUpperCase 首字母是否大写 (true -> "UserName", false -> "userName")
     * @return 转换后的驼峰命名字符串
     */
    public static String toCamelCase(String str, boolean firstCharUpperCase) {
        if (str == null || str.isEmpty()) {
            return "";
        }
        String[] parts = str.toLowerCase().split("_");
        StringBuilder camel = new StringBuilder();
        for (int i = 0; i < parts.length; i++) {
            String part = parts[i];
            if (part != null && !part.isEmpty()) {
                if (i == 0 && !firstCharUpperCase) {
                    camel.append(part);
                } else {
                    camel.append(Character.toUpperCase(part.charAt(0))).append(part.substring(1));
                }
            }
        }
        return camel.toString();
    }

    /**
     * 将 JDBC 数据类型字符串映射为 Java 类型的完全限定名。
     * @param jdbcType 从数据库元数据获取的类型字符串 (e.g., "VARCHAR", "BIGINT")
     * @return 对应的 Java 类型的全名 (e.g., "java.lang.String", "java.lang.Long")
     */
    public static String mapJdbcTypeToFullName(String jdbcType) {
        if (jdbcType == null) {
            return "java.lang.Object";
        }
        String type = jdbcType.toUpperCase();
        if (type.contains("VARCHAR") || type.contains("CHAR") || type.contains("TEXT") || type.contains("CLOB")) {
            return "java.lang.String";
        } else if (type.contains("INT")) { // Covers INT, INTEGER, TINYINT, SMALLINT
            return "java.lang.Integer";
        } else if (type.contains("BIGINT")) {
            return "java.lang.Long";
        } else if (type.contains("BIT") || type.contains("BOOLEAN")) { // BIT(1) is often used for booleans
            return "java.lang.Boolean";
        } else if (type.contains("DOUBLE")) {
            return "java.lang.Double";
        } else if (type.contains("FLOAT") || type.contains("REAL")) {
            return "java.lang.Float";
        } else if (type.contains("DECIMAL") || type.contains("NUMERIC")) {
            return "java.math.BigDecimal";
        } else if (type.contains("DATE") || type.contains("TIMESTAMP") || type.contains("DATETIME")) { // DATETIME, TIMESTAMP often map to Date or LocalDateTime
            return "java.util.Date"; // Can be changed to java.time.LocalDateTime if preferred
        } else if (type.contains("TIME")) {
            return "java.sql.Time"; // Or java.time.LocalTime
        } else if (type.contains("BLOB")) {
            return "byte[]";
        }
        // 默认类型
        return "java.lang.Object";
    }

    public static String getSimpleJavaType(String fullName) {
        if (fullName.contains(".")) {
            return fullName.substring(fullName.lastIndexOf(".") + 1);
        }
        return fullName;
    }

    /**
     * 【新方法】处理数据库列名，生成最终的Java字段名。
     * 此方法会移除配置的前后缀，并转换为小驼峰命名。
     * @param columnName 原始数据库列名
     * @param settings   包含忽略规则的设置对象
     * @return 处理后的Java字段名
     */
    public static String processColumnName(String columnName, GeneratorSettings settings) {
        String processedName = columnName;

        // 处理要忽略的前缀（支持逗号分割）
        String prefixes = settings.getIgnoreFieldPrefix();
        if (prefixes != null && !prefixes.trim().isEmpty()) {
            for (String prefix : prefixes.split(",")) {
                prefix = prefix.trim();
                // 使用不区分大小写的方式判断前缀
                if (!prefix.isEmpty() && processedName.toLowerCase().startsWith(prefix.toLowerCase())) {
                    processedName = processedName.substring(prefix.length());
                    break; // 只移除第一个匹配到的前缀
                }
            }
        }

        // 处理要忽略的后缀（支持逗号分割）
        String suffixes = settings.getIgnoreFieldSuffix();
        if (suffixes != null && !suffixes.trim().isEmpty()) {
            for (String suffix : suffixes.split(",")) {
                suffix = suffix.trim();
                // 使用不区分大小写的方式判断后缀
                if (!suffix.isEmpty() && processedName.toLowerCase().endsWith(suffix.toLowerCase())) {
                    processedName = processedName.substring(0, processedName.length() - suffix.length());
                    break; // 只移除第一个匹配到的后缀
                }
            }
        }

        // 最后将处理后的名字转为小驼峰
        return toCamelCase(processedName, false);
    }
}